Python Design Patterns: Principles of Good Design

Python Design Patterns: Principles of Good Design

• discover the key concepts covered in this course
• recall the basic principles of good design in code
• describe the Single Responsibility and Open/Closed principles of good design
• describe the Liskov's Substitution, Interface Segregation, and Dependency Inversion principles of good design
• describe the principle of Least Knowledge and the Hollywood principle of good design
• recognize issues that may arise when classes do not implement the principle of Single Responsibility
• design and implement the principle of Single Responsibility
• design and implement the Open/Closed principle
• design and implement the Liskov's Substitution principle
• design and implement the Interface Segregation principle
• design and implement the Dependency Inversion principle
• recall the three broad categories of design patterns
• describe the three types of design patterns and when to use each
• summarize the key concepts covered in this course

Explore how the SOLID principles can help to make software designs easier to understand and maintain. Examine the five SOLID principles - Single Responsibility, Open/Closed, Liskov's Substitution, Interface Segregation, and Dependency Inversion - as well as the creational, structural, and behavioral design patterns.

Python Design Patterns: Working with Behavioral Design Patterns

Python Design Patterns: Working with Behavioral Design Patterns

• discover the key concepts covered in this course
• describe the Strategy pattern and its use cases
• design and implement the Strategy pattern and recognize how it is used in Python built-in functions
• describe the Chain of Responsibility pattern and how it is used
• write code to implement the Chain of Responsibility pattern
• describe the Observer pattern and when it should be used
• implement the Observer pattern for a simple use case
• implement the Observer pattern for a more complex use case
• describe the Command pattern and its use cases
• implement the Command pattern to perform undo operations
• describe the Iterator pattern and its applications
• design an Iterator using special methods in Python
• summarize the key concepts covered in this course

Explore the design and implementation of five commonly used behavioral design patterns - Strategy, Chain of Responsibility, Observer, Command, and Iterator. Examine how these patterns can be used in Python built-in functions, in simple and complex use cases, for performing undo operations, and with Python special methods.

Python Design Patterns: Working with Creational Design Patterns

Python Design Patterns: Working with Creational Design Patterns

• discover the key concepts covered in this course
• recall how the Singleton pattern works and when to use this pattern
• write code for a simple implementation of the Singleton pattern
• implement the Singleton pattern using a more Pythonic style
• implement the Singleton pattern using global objects in Python
• recall how the Factory and Abstract Factory patterns work and when they can be used
• implement a simple design for the Factory pattern
• iteratively improve the design of code using refactoring
• design and implement the serializer using the Factory pattern
• apply the Abstract Factory pattern to create a family of objects
• recall how the Builder pattern works and when it should be used
• implement a simple design for the Builder pattern
• recall how the Object Pool pattern works and when it should be used
• implement the Object Pool pattern to limit the number of instances
• improve the Object Pool pattern by making the object pool a singleton
• summarize the key concepts covered in this course

Explore the details and implementation of five commonly used creational design patterns - Singleton, Factory, Abstract Factory, Builder, and Object Pool.

Python Design Patterns: Working with Structural Design Patterns

Python Design Patterns: Working with Structural Design Patterns

• discover the key concepts covered in this course
• recognize the design of the Adapter pattern and when it should be used
• recognize the need for the Adapter pattern when working with legacy components
• write code for the Adapter pattern to offer a consistent interface to clients
• describe the design of the Decorator pattern and its advantages
• recognize the importance of the Decorator pattern for adding responsibilities dynamically
• implement the Decorator pattern to allow adding responsibilities at runtime
• describe the design of the Façade pattern and where it is applied
• design and implement the Façade pattern to offer a simple interface to clients
• describe the design of the Proxy pattern and list its use cases
• design and implement the Proxy pattern to control access to an object
• describe the design of the Flyweight pattern and why it is used
• design and implement the Flyweight pattern to efficiently use lightweight resources
• summarize the key concepts covered in this course

Explore the design and implementation of five commonly used structural design patterns - Adapter, Decorator, Façade, Proxy, and Flyweight. Examine how these patterns can be used for tasks like working with legacy components, dynamically adding responsibilities, offering a simple client interface, controlling object access, and efficiently using lightweight resources.